home *** CD-ROM | disk | FTP | other *** search
/ Java Programmer's Toolkit / Java Programmer's Toolkit.iso / gs3.53 / gs_init.ps < prev    next >
Text File  |  1996-01-10  |  39KB  |  1,250 lines
  1. %    Copyright (C) 1989, 1995 Aladdin Enterprises.  All rights reserved.
  2. % 
  3. % This file is part of Aladdin Ghostscript.
  4. % 
  5. % Aladdin Ghostscript is distributed with NO WARRANTY OF ANY KIND.  No author
  6. % or distributor accepts any responsibility for the consequences of using it,
  7. % or for whether it serves any particular purpose or works at all, unless he
  8. % or she says so in writing.  Refer to the Aladdin Ghostscript Free Public
  9. % License (the "License") for full details.
  10. % 
  11. % Every copy of Aladdin Ghostscript must include a copy of the License,
  12. % normally in a plain ASCII text file named PUBLIC.  The License grants you
  13. % the right to copy, modify and redistribute Aladdin Ghostscript, but only
  14. % under certain conditions described in the License.  Among other things, the
  15. % License requires that the copyright notice and this notice be preserved on
  16. % all copies.
  17.  
  18. % Initialization file for the interpreter.
  19. % When this is run, systemdict is still writable.
  20.  
  21. % Comment lines of the form
  22. %    %% Replace <n> <file(s)>
  23. % indicate places where the next <n> lines should be replaced by
  24. % the contents of <file(s)>, when creating a single merged init file.
  25.  
  26. % The interpreter can call out to PostScript code.  All procedures
  27. % called in this way, and no other procedures defined in these
  28. % initialization files, have names that begin with %, e.g.,
  29. % (%Type1BuildChar) cvn.
  30.  
  31. % Check the interpreter revision.  NOTE: the interpreter code requires
  32. % that the first non-comment token in this file be an integer.
  33. 353
  34. dup revision ne
  35.  { (gs: Interpreter revision \() print revision 10 string cvs print
  36.    (\) does not match gs_init.ps revision \() print 10 string cvs print
  37.    (\).\n) print flush null 1 .quit
  38.  }
  39. if pop
  40.  
  41. % Acquire userdict, and set its length if necessary.
  42. /userdict where
  43.  { pop userdict maxlength 0 eq }
  44.  { true }
  45. ifelse
  46.  {        % userdict wasn't already set up by iinit.c.
  47.    /userdict
  48.    currentdict dup 200 .setmaxlength        % userdict
  49.    systemdict begin def        % can't use 'put', userdict is local
  50.  }
  51.  { systemdict begin
  52.  }
  53. ifelse
  54.  
  55. % Define true and false.
  56. /true 0 0 eq def
  57. /false 0 1 eq def
  58.  
  59. % Define dummy local/global operators if needed.
  60. systemdict /.setglobal known
  61.  { true .setglobal
  62.  }
  63.  { /.setglobal { pop } bind def
  64.    /.currentglobal { false } bind def
  65.    /.gcheck { pop false } bind def
  66.  }
  67. ifelse
  68.  
  69. % Define .languagelevel if needed.
  70. systemdict /.languagelevel known not { /.languagelevel 1 def } if
  71.  
  72. % Optionally choose a default paper size other than U.S. letter.
  73. % (a4) /PAPERSIZE where { pop pop } { /PAPERSIZE exch def } ifelse
  74.  
  75. % Turn on array packing for the rest of initialization.
  76. true setpacking
  77.  
  78. % Define the old MS-DOS EOF character as a no-op.
  79. % This is a hack to get around the absurd habit of MS-DOS editors
  80. % of adding an EOF character at the end of the file.
  81. <1a> cvn { } def
  82.  
  83. % Acquire the debugging flags.
  84. currentdict /DEBUG known   /DEBUG exch def
  85.   /VMDEBUG
  86.     DEBUG {{print mark
  87.             systemdict /level2dict known
  88.          { .currentglobal dup false .setglobal vmstatus
  89.            true .setglobal vmstatus 3 -1 roll pop
  90.            6 -2 roll pop .setglobal
  91.          }
  92.          { vmstatus 3 -1 roll pop
  93.          }
  94.         ifelse usertime 16#fffff and counttomark
  95.           { ( ) print (           ) cvs print }
  96.         repeat pop
  97.         ( ) print systemdict length (    ) cvs print
  98.         ( <) print count (    ) cvs print (>\n) print flush
  99.       }}
  100.       {{pop
  101.       }}
  102.      ifelse
  103.   def
  104.  
  105. currentdict /DISKFONTS known   /DISKFONTS exch def
  106. currentdict /ESTACKPRINT known   /ESTACKPRINT exch def
  107. currentdict /FAKEFONTS known   /FAKEFONTS exch def
  108. currentdict /FIXEDMEDIA known   /FIXEDMEDIA exch def
  109. currentdict /FIXEDRESOLUTION known   /FIXEDRESOLUTION exch def
  110. currentdict /LOCALFONTS known   /LOCALFONTS exch def
  111. currentdict /NOBIND known   /NOBIND exch def
  112. /.bind /bind load def
  113. NOBIND { /bind { } def } if
  114. currentdict /NOCACHE known   /NOCACHE exch def
  115. currentdict /NOCIE known   /NOCIE exch def
  116. currentdict /NODISPLAY known   not /DISPLAYING exch def
  117. currentdict /NOFONTMAP known   /NOFONTMAP exch def
  118. currentdict /NOFONTPATH known   /NOFONTPATH exch def
  119. currentdict /NOGC known   /NOGC exch def
  120. currentdict /NOPAUSE known   /NOPAUSE exch def
  121. currentdict /NOPLATFONTS known   /NOPLATFONTS exch def
  122. currentdict /NOPROMPT known   /NOPROMPT exch def
  123. currentdict /ORIENT1 known   /ORIENT1 exch def
  124. currentdict /OSTACKPRINT known   /OSTACKPRINT exch def
  125. currentdict /OUTPUTFILE known    % obsolete
  126.  { /OutputFile /OUTPUTFILE load def
  127.    currentdict /OUTPUTFILE undef
  128.  } if
  129. currentdict /QUIET known   /QUIET exch def
  130. currentdict /SAFER known   /SAFER exch def
  131. currentdict /SHORTERRORS known   /SHORTERRORS exch def
  132. currentdict /WRITESYSTEMDICT known   /WRITESYSTEMDICT exch def
  133.  
  134. % Acquire environment variables.
  135. currentdict /DEVICE known not
  136.  { (GS_DEVICE) getenv { /DEVICE exch def } if } if
  137.  
  138. (START) VMDEBUG
  139.  
  140. % Open the standard files, so they will be open at the outermost save level.
  141. (%stdin) (r) file pop
  142. (%stdout) (w) file pop
  143. (%stderr) (w) file pop
  144.  
  145. % Define a procedure for skipping over an unneeded section of code.
  146. % This avoids allocating space for the skipped procedures.
  147. % We can't use readline, because that imposes a line length limit.
  148. /.skipeof    % <string> .skipeof -
  149.  { currentfile exch 1 exch //filterdict /SubFileDecode get exec
  150.    flushfile
  151.  } bind def
  152.  
  153. % Define =string, which is used by some PostScript programs even though
  154. % it isn't documented anywhere.
  155. % Put it in userdict so that each context can have its own copy.
  156. userdict /=string 256 string put
  157.  
  158. % Print the greeting.
  159.  
  160. /printgreeting
  161.  { mark
  162.    product (Ghostscript) search
  163.     { pop pop pop
  164.       (This software comes with NO WARRANTY: see the file PUBLIC for details.\n)
  165.     }
  166.     { pop
  167.     }
  168.    ifelse
  169.    (\n) copyright
  170.    (\)\n) revisiondate 100 mod (-)
  171.    revisiondate 100 idiv 100 mod (-)
  172.    revisiondate 10000 idiv ( \()
  173.    revision 10 mod
  174.    revision 10 idiv 10 mod (.)
  175.    revision 100 idiv ( )
  176.    product
  177.    counttomark
  178.     { (%stdout) (w) file exch .writecvs
  179.     } repeat pop
  180.  } bind def
  181.  
  182. QUIET not { printgreeting flush } if
  183.  
  184. % Define a special version of def for making operator procedures.
  185. /odef
  186.     {1 index exch .makeoperator def} bind def
  187.  
  188. %**************** BACKWARD COMPATIBILITY
  189. /getdeviceprops
  190.  { null .getdeviceparams
  191.  } bind odef
  192. /.putdeviceprops
  193.  { null true counttomark 1 add 3 roll .putdeviceparams
  194.    dup type /booleantype ne
  195.     { dup mark eq { /unknown /rangecheck } if
  196.       counttomark 4 add 1 roll cleartomark pop pop pop
  197.       /.putdeviceprops load exch signalerror
  198.     }
  199.    if
  200.  } bind odef
  201. /.devicenamedict 1 dict dup /OutputDevice dup put def
  202. /.devicename
  203.  { //.devicenamedict .getdeviceparams exch pop exch pop
  204.  } bind odef
  205. /max { .max } bind def
  206. /min { .min } bind def
  207.  
  208. % Define predefined procedures substituting for operators,
  209. % in alphabetical order.
  210.  
  211. userdict /#copies 1 put
  212. /[    /mark load def
  213. /]     {counttomark array astore exch pop} odef
  214. /abs    {dup 0 lt {neg} if} odef
  215. % .beginpage is an operator in Level 2.
  216. /.beginpage { } odef
  217. /copypage
  218.     { 1 .endpage
  219.        { .currentnumcopies false .outputpage
  220.          (>>copypage, press <return> to continue<<\n) .confirm
  221.        }
  222.       if .beginpage
  223.     } odef
  224. % .currentnumcopies is redefined in Level 2.
  225. /.currentnumcopies { #copies } odef
  226. /setcolorscreen where { pop        % not in all Level 1 configurations
  227.    /currentcolorscreen
  228.     { .currenthalftone
  229.        { { 60 exch 0 exch 3 copy 6 copy }    % halftone - not possible
  230.          { 3 copy 6 copy }            % screen
  231.          { }                % colorscreen
  232.        }
  233.       exch get exec
  234.     } odef
  235. } if
  236. /currentscreen
  237.     { .currenthalftone
  238.        { { 60 exch 0 exch }            % halftone - not possible
  239.          { }                % screen
  240.          { 12 3 roll 9 { pop } repeat }    % colorscreen
  241.        }
  242.       exch get exec
  243.     } odef
  244. /.echo /echo load def
  245. userdict /.echo.mode true put
  246. /echo    {dup /.echo.mode exch store .echo} odef
  247. /eexec
  248.     { 55665 //filterdict /eexecDecode get exec
  249.       cvx systemdict begin stopped
  250.         % Only pop systemdict if it is still the top element,
  251.         % because this is apparently what Adobe interpreters do.
  252.       currentdict systemdict eq { end } if
  253.       { stop } if
  254.     } odef
  255. % .endpage is an operator in Level 2.
  256. /.endpage { 2 ne } odef
  257. % erasepage mustn't use gsave/grestore, because we call it before
  258. % the graphics state stack has been fully initialized.
  259. /erasepage
  260.     { /currentcolor where
  261.        { pop currentcolor currentcolorspace { setcolorspace setcolor } }
  262.        { /currentcmykcolor where
  263.           { pop currentcmykcolor { setcmykcolor } }
  264.           { currentrgbcolor { setrgbcolor } }
  265.          ifelse
  266.        }
  267.       ifelse 1 setgray .fillpage exec
  268.     } odef
  269. /executive
  270.     { { prompt
  271.          { (%statementedit) (r) file } stopped
  272.          { pop pop $error /errorname get /undefinedfilename eq
  273.         { exit } if        % EOF
  274.            handleerror null        % ioerror??
  275.          }
  276.         if
  277.         cvx execute
  278.       } loop
  279.     } odef
  280. /filter
  281.     { //filterdict 1 index .knownget
  282.        { exch pop exec }
  283.        { /filter load /undefined signalerror }
  284.       ifelse
  285.     } odef
  286. /handleerror
  287.     { errordict /handleerror get exec } bind def
  288. /identmatrix [1.0 0.0 0.0 1.0 0.0 0.0] readonly def
  289. /identmatrix
  290.     { //identmatrix exch copy } odef
  291. /initgraphics
  292.     { initmatrix newpath initclip
  293.       1 setlinewidth 0 setlinecap 0 setlinejoin
  294.       [] 0 setdash 0 setgray 10 setmiterlimit
  295.     } odef
  296. /languagelevel 1 def        % gs_lev2.ps may change this
  297. /makeimagedevice { false makewordimagedevice } odef
  298. /matrix    { 6 array identmatrix } odef
  299. /pathbbox { false .pathbbox } odef
  300. /prompt    { flush flushpage
  301.       (GS) print
  302.       count 0 ne { (<) print count =only } if
  303.       (>) print flush
  304.     } bind def
  305. /pstack    { 0 1 count 3 sub { index == } for } bind def
  306. /putdeviceprops
  307.     { .putdeviceprops { erasepage } if } odef
  308. /quit    { /quit load 0 .quit } odef
  309. /run    { dup type /filetype ne { (r) file } if cvx
  310.         % We must close the file when execution terminates,
  311.         % regardless of the state of the stack,
  312.         % and then propagate an error, if any.
  313.       cvx .runexec
  314.     } odef
  315. /setdevice
  316.     { .setdevice { erasepage } if } odef
  317. /showpage
  318.     { 0 .endpage
  319.        { .currentnumcopies true .outputpage
  320.          (>>showpage, press <return> to continue<<\n) .confirm
  321.          erasepage
  322.        }
  323.       if initgraphics .beginpage
  324.     } odef
  325. % Code output by Adobe Illustrator relies on the fact that
  326. % `stack' is a procedure, not an operator!!!
  327. /stack    { 0 1 count 3 sub { index = } for } bind def
  328. /start    { executive } def
  329. /stop    { true .stop } odef
  330. /stopped { false .stopped } odef
  331. /store    { 1 index where { 3 1 roll put } { def } ifelse } odef
  332. % When running in Level 1 mode, this interpreter is supposed to be
  333. % compatible with PostScript "version" 54.0 (I think).
  334. /version (54.0) def
  335.  
  336. % internaldict is defined in systemdict, but is allocated in local VM.
  337. systemdict /internaldict .knownget not { 0 } if type /operatortype ne
  338.  { .currentglobal false .setglobal
  339.    systemdict /internaldict known not { /internaldict 5 dict def } if
  340.    /internaldict
  341.     [ /dup load 1183615869 /eq load
  342.        [ /pop load internaldict ] cvx
  343.        [ /internaldict /cvx load /invalidaccess /signalerror cvx ] cvx
  344.       /ifelse load
  345.     ] cvx bind odef
  346.    .setglobal
  347.  } if
  348.  
  349. % Define some additional built-in procedures (beyond the ones defined by
  350. % the PostScript Language Reference Manual).
  351. % Warning: these are not guaranteed to stay the same from one release
  352. % to the next!
  353. /concatstrings
  354.     { exch dup length 2 index length add string    % str2 str1 new
  355.       dup dup 4 2 roll copy        % str2 new new new1
  356.       length 4 -1 roll putinterval
  357.     } bind def
  358. /copyarray
  359.     { dup length array copy } bind def
  360. /copystring
  361.     { dup length string copy } bind def
  362. /finddevice
  363.     { systemdict /devicedict get exch get
  364.     } bind def
  365. /.growdictlength    % get size for growing a dictionary
  366.     { length 3 mul 2 idiv 1 add
  367.     } bind def
  368. /.growdict        % grow a dictionary
  369.     { dup .growdictlength .setmaxlength
  370.     } bind def
  371. /.growput        % put, grow the dictionary if needed
  372.     { 2 index length 3 index maxlength eq
  373.        { 3 copy pop known not { 2 index .growdict } if
  374.        } if
  375.       put
  376.     } bind def
  377. /.packtomark
  378.     { counttomark packedarray exch pop } bind def
  379. /runlibfile
  380.     { findlibfile
  381.        { exch pop run }
  382.        { /undefinedfilename signalerror }
  383.       ifelse
  384.     } bind def
  385. /selectdevice
  386.     { finddevice setdevice .setdefaultscreen } bind def
  387. /signalerror        % <object> <errorname> signalerror -
  388.     { errordict exch get exec } bind def
  389.  
  390. % Define the =[only] procedures.  Also define =print,
  391. % which is used by some PostScript programs even though
  392. % it isn't documented anywhere.
  393. /write=only
  394.     { { .writecvs } null .stopped null ne
  395.        { pop (--nostringval--) writestring
  396.        }
  397.       if
  398.     } bind def
  399. /write=
  400.     { 1 index exch write=only (\n) writestring
  401.     } bind def
  402. /=only    { (%stdout) (w) file exch write=only } bind def
  403. /=    { =only (\n) print } bind def
  404. /=print    /=only load def
  405. % Temporarily define == as = for the sake of runlibfile0.
  406. /== /= load def
  407.  
  408. % Define procedures for getting and setting the current device resolution.
  409.  
  410. /gsgetdeviceprop    % <device> <propname> gsgetdeviceprop <value>
  411.  { 2 copy mark exch null .dicttomark .getdeviceparams
  412.    dup mark eq        % if true, not found
  413.     { pop dup /undefined signalerror }
  414.     { 5 1 roll pop pop pop pop }
  415.    ifelse
  416.  } bind def
  417. /gscurrentresolution    % - gscurrentresolution <[xres yres]>
  418.  { currentdevice /HWResolution gsgetdeviceprop
  419.  } bind def
  420. /gssetresolution    % <[xres yres]> gssetresolution -
  421.  { 2 array astore mark exch /HWResolution exch
  422.    currentdevice copydevice putdeviceprops setdevice
  423.  } bind def
  424.  
  425. % Define auxiliary procedures needed for the above.
  426. /shellarguments        % -> shell_arguments true (or) false
  427.     { /ARGUMENTS where
  428.        { /ARGUMENTS get dup type /arraytype eq
  429.           { aload pop /ARGUMENTS null store true }
  430.           { pop false }
  431.          ifelse }
  432.        { false } ifelse
  433.     } bind def
  434. /.confirm
  435.     { DISPLAYING NOPAUSE not and
  436.        {    % Print a message (unless NOPROMPT is true)
  437.         % and wait for the user to type something.
  438.         % If the user just types a newline, flush it.
  439.          NOPROMPT { pop } { print flush } ifelse
  440.          .echo.mode false echo
  441.          (%stdin) (r) file dup read
  442.           { dup (\n) 0 get eq { pop pop } { unread } ifelse }
  443.           { pop }
  444.          ifelse echo
  445.        }
  446.        { pop
  447.        }
  448.       ifelse
  449.     } bind def
  450.  
  451. % Define the procedure used by .runfile, .runstdin and .runstring
  452. % for executing user input.
  453. % This is called with a procedure or executable file on the operand stack.
  454. /execute
  455.     { stopped $error /newerror get and
  456.        { handleerror flush
  457.        } if
  458.     } odef
  459. % Define an execute analogue of runlibfile0.
  460. /execute0
  461.     { stopped $error /newerror get and
  462.        { handleerror flush /execute0 cvx 1 .quit
  463.        } if
  464.     } bind def
  465. % Define the procedure that the C code uses for running files
  466. % named on the command line.
  467. /.runfile { { runlibfile } execute } def
  468. % Define the procedure that the C code uses for running piped input.
  469. /.runstdin { (%stdin) (r) file cvx execute0 } bind def
  470. % Define the procedure that the C code uses for running commands
  471. % given on the command line with -c.
  472. /.runstring { cvx execute } def
  473.  
  474. % Define a special version of runlibfile that aborts on errors.
  475. /runlibfile0
  476.     { cvlit dup /.currentfilename exch def
  477.        { findlibfile not { stop } if }
  478.       stopped
  479.        { (Can't find \(or open\) initialization file ) print
  480.          .currentfilename == flush /runlibfile0 cvx 1 .quit
  481.        } if
  482.       exch pop cvx stopped
  483.        { (While reading ) print .currentfilename print (:\n) print flush
  484.          handleerror /runlibfile0 1 .quit
  485.        } if
  486.     } bind def
  487. % Temporarily substitute it for the real runlibfile.
  488. /.runlibfile /runlibfile load def
  489. /runlibfile /runlibfile0 load def
  490.  
  491. % Create the error handling machinery.
  492. % Define the standard error handlers.
  493. % The interpreter has created the ErrorNames array.
  494. /.unstoppederrorhandler    % <command> <errorname> .unstoppederrorhandler -
  495.  {    % This is the handler that gets used for recursive errors,
  496.     % or errors outside the scope of a 'stopped'.
  497.    2 copy SHORTERRORS
  498.     { (%%[ Error: ) print =only flush
  499.       (; OffendingCommand: ) print =only ( ]%%\n) print
  500.     }
  501.     { (Unrecoverable error: ) print =only flush
  502.       ( in ) print = flush
  503.       count 2 gt
  504.        { (Operand stack:\n  ) print
  505.      2 1 count 3 sub { (  ) print index =only flush } for
  506.      (\n) print flush
  507.        } if
  508.     }
  509.    ifelse
  510.    -1 0 1 //ErrorNames length 1 sub
  511.     { dup //ErrorNames exch get 3 index eq
  512.        { not exch pop exit } { pop } ifelse
  513.     }
  514.    for exch pop .quit
  515.  } bind def
  516. /.errorhandler        % <command> <errorname> .errorhandler -
  517.   {        % Detect an internal 'stopped'.
  518.     .instopped { null eq { pop pop stop } if } if
  519.     $error /.inerror get .instopped { pop } { pop true } ifelse
  520.      { .unstoppederrorhandler
  521.      } if    % detect error recursion
  522.     $error /globalmode .currentglobal false .setglobal put
  523.     $error /.inerror true put
  524.     $error /newerror true put
  525.     $error exch /errorname exch put
  526.     $error exch /command exch put
  527.     $error /recordstacks get $error /errorname get /VMerror ne and
  528.      {        % Attempt to store the stack contents atomically.
  529.        count array astore dup $error /ostack 4 -1 roll
  530.        countexecstack array execstack $error /estack 3 -1 roll
  531.        countdictstack array dictstack $error /dstack 3 -1 roll
  532.        put put put aload pop
  533.      }
  534.      { $error /dstack undef
  535.        $error /estack undef
  536.        $error /ostack undef
  537.      }
  538.     ifelse
  539.     $error /position currentfile status
  540.      { currentfile { fileposition } null .stopped null ne { pop null } if
  541.      }
  542.      { null
  543.      }
  544.     ifelse put
  545.         % During initialization, we don't reset the allocation
  546.         % mode on errors.
  547.     $error /globalmode get $error /.nosetlocal get and .setglobal
  548.     $error /.inerror false put
  549.     stop
  550.   } bind def
  551. % Define the standard handleerror.  We break out the printing procedure
  552. % (.printerror) so that it can be extended for binary output
  553. % if the Level 2 facilities are present.
  554.   /.printerror
  555.    { $error begin
  556.        /command load errorname SHORTERRORS
  557.     { (%%[ Error: ) print =only flush
  558.       (; OffendingCommand: ) print =only
  559.       currentdict /errorinfo .knownget
  560.        { (;\nErrorInfo:) print
  561.          dup type /arraytype eq
  562.           { { ( ) print =only } forall }
  563.           { ( ) print =only }
  564.          ifelse
  565.        } if
  566.           ( ]%%\n) print flush
  567.     }
  568.     { (Error: ) print ==only flush
  569.       ( in ) print ==only flush
  570.       currentdict /errorinfo .knownget
  571.        { (\nAdditional information: ) print ==only flush
  572.        } if
  573.       .printerror_long
  574.     }
  575.        ifelse
  576.        .clearerror
  577.      end
  578.      flush
  579.     } bind def     
  580.   /.printerror_long            % long error printout,
  581.                     % $error is on the dict stack
  582.    {    % Push the (anonymous) stack printing procedure.
  583.     %  <heading> <==flag> <override-name> <stackname> proc
  584.        {
  585.      currentdict exch .knownget    % stackname defined in $error?
  586.      {
  587.        4 1 roll            % stack: <stack> <head> <==flag> <over>
  588.        errordict exch .knownget    % overridename defined?
  589.        { 
  590.          exch pop exch pop exec    % call override with <stack>
  591.        }
  592.        { 
  593.          exch print exch        % print heading. stack <==flag> <stack>
  594.          1 index not { (\n) print } if
  595.          { 1 index { (\n    ) } { (   ) } ifelse print
  596.            dup type /dicttype eq
  597.            {
  598.          (--dict:) print
  599.          dup rcheck
  600.           { dup length =only (/) print maxlength =only }
  601.           { pop }
  602.          ifelse
  603.          (--) print
  604.            }
  605.            {
  606.          dup type /stringtype eq 2 index or
  607.          { ==only } { =only } ifelse
  608.            } ifelse
  609.          } forall
  610.          pop
  611.        }
  612.        ifelse            % overridden
  613.      }
  614.      { pop pop pop
  615.      }
  616.      ifelse                % stack known
  617.        }
  618.  
  619.        (\nOperand stack:) OSTACKPRINT /.printostack /ostack 4 index exec
  620.        (\nExecution stack:) ESTACKPRINT /.printestack /estack 4 index exec
  621.        (\nBacktrace:) true /.printbacktrace /backtrace 4 index exec
  622.        (\nDictionary stack:) false /.printdstack /dstack 4 index exec
  623.        (\n) print
  624.        pop    % printing procedure
  625.  
  626.        errorname /VMerror eq
  627.     { (VM status:) print mark vmstatus
  628.       counttomark { ( ) print counttomark -1 roll dup =only } repeat
  629.       cleartomark (\n) print
  630.     } if
  631.  
  632.        .languagelevel 2 ge
  633.     { (Current allocation mode is ) print
  634.       globalmode { (global\n) } { (local\n) } ifelse print
  635.     } if
  636.  
  637.        .oserrno dup 0 ne
  638.     { (Last OS error: ) print
  639.       errorname /VMerror ne
  640.        { dup .oserrorstring { = pop } { = } ifelse }
  641.        { = }
  642.       ifelse
  643.     }
  644.     { pop
  645.     }
  646.        ifelse
  647.  
  648.        position null ne
  649.     { (Current file position is ) print position = }
  650.        if
  651.  
  652.    } bind def
  653. % Define a procedure for clearing the error indication.
  654. /.clearerror
  655.  { $error /newerror false put
  656.    $error /errorinfo undef
  657.    0 .setoserrno
  658.  } bind def
  659.  
  660. % Define $error.  This must be in local VM.
  661. .currentglobal false .setglobal
  662. /$error 40 dict def        % newerror, errorname, command, errorinfo,
  663.                 % ostack, estack, dstack, recordstacks,
  664.                 % binary, globalmode,
  665.                 % .inerror, .nosetlocal, position,
  666.         % plus extra space for badly designed error handers.
  667. $error begin
  668.   /newerror false def
  669.   /recordstacks true def
  670.   /binary false def
  671.   /globalmode .currentglobal def
  672.   /.inerror false def
  673.   /.nosetlocal true def
  674.   /position null def
  675. end
  676. % Define errordict similarly.  It has one entry per error name,
  677. %   plus handleerror.
  678. /errordict ErrorNames length 1 add dict def
  679. .setglobal        % contents of errordict are global
  680. errordict begin
  681.   ErrorNames
  682.    { mark 1 index systemdict /.errorhandler get /exec load .packtomark cvx def
  683.    } forall
  684. % The handlers for interrupt and timeout are special; there is no
  685. % 'current object', so they push their own name.
  686.    { /interrupt /timeout }
  687.    { mark 1 index dup systemdict /.errorhandler get /exec load .packtomark cvx def
  688.    } forall
  689. /handleerror
  690.  { systemdict /.printerror get exec
  691.  } bind def
  692. end
  693.  
  694. % Define the [write]==[only] procedures.
  695. /.dict 26 dict dup
  696. begin def
  697.   /.cvp {1 index exch .writecvs} bind def
  698.   /.nop {exch pop .p} bind def
  699.   /.p {1 index exch writestring} bind def
  700.   /.p1 {2 index exch writestring} bind def
  701.   /.p2 {3 index exch writestring} bind def
  702.   /.print
  703.     { dup type .dict exch .knownget
  704.        { dup type /stringtype eq { .nop } { exec } ifelse }
  705.        { (-) .p1 type .cvp (-) .p }
  706.       ifelse
  707.     } bind def
  708.   /.pstring
  709.     {  { dup dup 32 lt exch 127 ge or
  710.           { (\\) .p1 2 copy -6 bitshift 48 add write
  711.         2 copy -3 bitshift 7 and 48 add write
  712.         7 and 48 add
  713.           }
  714.           { dup dup -2 and 40 eq exch 92 eq or {(\\) .p1} if
  715.           }
  716.          ifelse 1 index exch write
  717.        }
  718.       forall
  719.     } bind def  
  720.   /booleantype /.cvp load def
  721.   /conditiontype (-condition-) def
  722.   /devicetype (-device-) def
  723.   /dicttype (-dict-) def
  724.   /filetype (-file-) def
  725.   /fonttype (-fontID-) def
  726.   /gstatetype (-gstate-) def
  727.   /integertype /.cvp load def
  728.   /locktype (-lock-) def
  729.   /marktype (-mark-) def
  730.   /nulltype (null) def
  731.   /realtype /.cvp load def
  732.   /savetype (-save-) def
  733.   /nametype
  734.     {dup xcheck not {(/) .p1} if
  735.      1 index exch .writecvs} bind def
  736.   /arraytype
  737.     {dup rcheck
  738.       {() exch dup xcheck
  739.         {({) .p2
  740.          {exch .p1
  741.           1 index exch .print pop ( )} forall
  742.          (})}
  743.         {([) .p2
  744.          {exch .p1
  745.           1 index exch .print pop ( )} forall
  746.          (])}
  747.        ifelse exch pop .p}
  748.       {(-array-) .nop}
  749.      ifelse} bind def
  750.   /operatortype
  751.       {(--) .p1 .cvp (--) .p} bind def
  752.   /packedarraytype
  753.     { dup rcheck
  754.        { arraytype }
  755.        { (-packedarray-) .nop }
  756.       ifelse
  757.     } bind def
  758.   /stringtype
  759.     { dup rcheck
  760.        { (\() .p1 dup length 200 le
  761.           { .pstring }
  762.           { 0 200 getinterval .pstring (...) .p }
  763.          ifelse (\)) .p
  764.        }
  765.        { (-string-) .nop
  766.        }
  767.       ifelse
  768.     } bind def
  769. {//.dict begin .print pop end}
  770.   bind cvx
  771. end
  772.  
  773. /write==only exch def
  774. /write==
  775.     {1 index exch write==only (\n) writestring} bind def
  776. /==only    { (%stdout) (w) file exch write==only } bind def
  777. /==    {==only (\n) print} bind def
  778.  
  779. (END PROCS) VMDEBUG
  780.  
  781. % Define the font directory.
  782. % Make it big to leave room for transformed fonts.
  783. /FontDirectory false .setglobal 100 dict true .setglobal def
  784.  
  785. % Define the encoding dictionary.
  786. /EncodingDirectory 10 dict def    % enough for Level 2 + PDF standard encodings
  787.  
  788. % Define findencoding.  (This is redefined in Level 2.)
  789. /.findencoding
  790.  { //EncodingDirectory exch get exec
  791.  } bind def
  792. /.defineencoding
  793.  { //EncodingDirectory 3 1 roll put
  794.  } bind def
  795.  
  796. % Load StandardEncoding.
  797. %% Replace 1 (gs_std_e.ps)
  798. (gs_std_e.ps) dup runlibfile VMDEBUG
  799.  
  800. % Load ISOLatin1Encoding.
  801. %% Replace 1 (gs_iso_e.ps)
  802. (gs_iso_e.ps) dup runlibfile VMDEBUG
  803.  
  804. % Define stubs for the Symbol and Dingbats encodings.
  805. % Note that the first element of the procedure must be the file name,
  806. % since gs_lev2.ps extracts it to set up the Encoding resource category.
  807.  
  808.   /SymbolEncoding { /SymbolEncoding .findencoding } bind def
  809. %% Replace 3 (gs_sym_e.ps)
  810.   EncodingDirectory /SymbolEncoding
  811.    { (gs_sym_e.ps) systemdict begin runlibfile SymbolEncoding end }
  812.   bind put
  813.  
  814.   /DingbatsEncoding { /DingbatsEncoding .findencoding } bind def
  815. %% Replace 3 (gs_dbt_e.ps)
  816.   EncodingDirectory /DingbatsEncoding
  817.    { (gs_dbt_e.ps) systemdict begin runlibfile DingbatsEncoding end }
  818.   bind put
  819.  
  820. (END FONTDIR/ENCS) VMDEBUG
  821.  
  822. % Construct a dictionary of all available devices.
  823. mark
  824.     % Loop until the .getdevice gets a rangecheck.
  825.   errordict /rangecheck 2 copy get
  826.   errordict /rangecheck { pop stop } put    % pop the command
  827.   0 { {dup .getdevice exch 1 add} loop} stopped pop
  828.   dict /devicedict exch def
  829.   devicedict begin        % 2nd copy of count is on stack
  830.    { dup .devicename dup 3 -1 roll def
  831.      counttomark 1 roll
  832.    } repeat
  833.   end put
  834. counttomark packedarray /devicenames exch def pop
  835. .clearerror
  836.  
  837. % Determine the default device.
  838. /defaultdevice DISPLAYING
  839.  { systemdict /DEVICE .knownget
  840.     { devicedict exch .knownget not
  841.        { (Unknown device: ) print DEVICE =
  842.      flush /defaultdevice cvx 1 .quit
  843.        }
  844.       if
  845.     }
  846.     { 0 .getdevice
  847.     }
  848.    ifelse
  849.  }
  850.  { /nullpage finddevice
  851.  }
  852. ifelse def
  853.  
  854. (END DEVS) VMDEBUG
  855.  
  856. % Define statusdict, for the benefit of programs
  857. % that think they are running on a LaserWriter or similar printer.
  858. %% Replace 1 (gs_statd.ps)
  859. (gs_statd.ps) runlibfile
  860.  
  861. (END STATD) VMDEBUG
  862.  
  863. % Load the standard font environment.
  864. %% Replace 1 (gs_fonts.ps)
  865. (gs_fonts.ps) runlibfile
  866.  
  867. (END GS_FONTS) VMDEBUG
  868.  
  869. % Load the initialization files for optional features.
  870. %% Replace 4 INITFILES
  871. systemdict /INITFILES known
  872.  { INITFILES { dup runlibfile VMDEBUG } forall
  873.  }
  874. if
  875.  
  876. % If Level 2 functionality is implemented, enable it now.
  877. /.setlanguagelevel where
  878.  { pop 2 .setlanguagelevel
  879.  } if
  880.  
  881. % If the resource machinery was loaded, convert encodings to resources.
  882. /defineresource where
  883.  { pop EncodingDirectory
  884.     { dup length 256 eq
  885.        { /Encoding defineresource pop }
  886.        { pop pop }
  887.       ifelse
  888.     } forall
  889.  } if
  890.  
  891. (END INITFILES) VMDEBUG
  892.  
  893. % Create a null font.  This is the initial font.
  894. 8 dict dup begin
  895.   /FontMatrix [ 1 0 0 1 0 0 ] readonly def
  896.   /FontType 3 def
  897.   /FontName () def
  898.   /Encoding StandardEncoding def
  899.   /FontBBox { 0 0 0 0 } readonly def % executable is bogus, but customary ...
  900.   /BuildChar { pop pop 0 0 setcharwidth } bind def
  901.   /PaintType 0 def        % shouldn't be needed!
  902. end
  903. /NullFont exch definefont setfont
  904.  
  905. % Define NullFont as the font.
  906. /NullFont currentfont def
  907.  
  908. % Load initial fonts from FONTPATH directories, Fontmap file,
  909. % and/or .getccfont as appropriate.
  910. .loadinitialfonts
  911.  
  912. % Remove NullFont from FontDirectory, so it can't be accessed by mistake.
  913. FontDirectory /NullFont undef
  914.  
  915. (END FONTS) VMDEBUG
  916.  
  917. % Restore the real definition of runlibfile.
  918. /runlibfile /.runlibfile load def
  919. currentdict /.runlibfile undef
  920.  
  921. % Bind all the operators defined as procedures.
  922. /.bindoperators        % binds operators in currentdict
  923.  { % Temporarily disable the typecheck error.
  924.    errordict /typecheck 2 copy get
  925.    errordict /typecheck { pop } put    % pop the command
  926.    currentdict
  927.     { dup type /operatortype eq
  928.        { % This might be a real operator, so bind might cause a typecheck,
  929.      % but we've made the error a no-op temporarily.
  930.      .bind        % do a real bind even if NOBIND is set
  931.        }
  932.       if pop pop
  933.     } forall
  934.    put
  935.  } def
  936. NOBIND not { .bindoperators } if
  937.  
  938. % Establish a default environment.
  939.  
  940. DISPLAYING not { (%END DISPLAYING) .skipeof } if
  941. defaultdevice
  942. systemdict /DEVICEWIDTH known
  943. systemdict /DEVICEHEIGHT known or
  944. systemdict /DEVICEWIDTHPOINTS known or
  945. systemdict /DEVICEHEIGHTPOINTS known or
  946. systemdict /DEVICEXRESOLUTION known or
  947. systemdict /DEVICEYRESOLUTION known or
  948. systemdict /PAPERSIZE known or
  949. not { (%END DEVICE) .skipeof } if
  950. % Let DEVICEWIDTH and DEVICEHEIGHT override PAPERSIZE.
  951. systemdict /PAPERSIZE known
  952. systemdict /DEVICEWIDTH known not and
  953. systemdict /DEVICEHEIGHT known not and
  954.  {    % Convert the paper size to device dimensions.
  955.    true statusdict /.pagetypenames get
  956.     { PAPERSIZE eq
  957.        { PAPERSIZE load
  958.          dup 0 get /DEVICEWIDTHPOINTS exch def
  959.          1 get /DEVICEHEIGHTPOINTS exch def
  960.          pop false exit
  961.        }
  962.       if
  963.     }
  964.    forall
  965.     { (Unknown paper size: ) print PAPERSIZE ==only (.\n) print
  966.     }
  967.    if
  968.  }
  969. if
  970. % Adjust the device parameters per the command line.
  971. % It is possible to specify resolution, pixel size, and page size;
  972. % since any two of these determine the third, conflicts are possible.
  973. % We simply pass them to .setdeviceparams and let it sort things out.
  974.    mark /HWResolution null /HWSize null /PageSize null .dicttomark
  975.    .getdeviceparams .dicttomark begin
  976.    mark
  977.     % Check for resolution.
  978.    /DEVICEXRESOLUTION where dup
  979.     { exch pop HWResolution 0 DEVICEXRESOLUTION put }
  980.    if
  981.    /DEVICEYRESOLUTION where dup
  982.     { exch pop HWResolution 1 DEVICEYRESOLUTION put }
  983.    if
  984.    or { /HWResolution HWResolution } if
  985.     % Check for device sizes specified in pixels.
  986.    /DEVICEWIDTH where dup
  987.     { exch pop HWSize 0 DEVICEWIDTH put }
  988.    if
  989.    /DEVICEHEIGHT where dup
  990.     { exch pop HWSize 1 DEVICEHEIGHT put }
  991.    if
  992.    or { /HWSize HWSize } if
  993.     % Check for device sizes specified in points.
  994.    /DEVICEWIDTHPOINTS where dup
  995.     { exch pop PageSize 0 DEVICEWIDTHPOINTS put }
  996.    if
  997.    /DEVICEHEIGHTPOINTS where dup
  998.     { exch pop PageSize 1 DEVICEHEIGHTPOINTS put }
  999.    if
  1000.    or { /PageSize PageSize } if
  1001.     % Check whether any parameters were set.
  1002.    dup mark eq { pop } { defaultdevice putdeviceprops } ifelse
  1003.    end
  1004. %END DEVICE
  1005. % Set any device properties defined on the command line.
  1006. dup getdeviceprops
  1007. counttomark 2 idiv
  1008.  { systemdict 2 index known
  1009.     { pop dup load counttomark 2 roll }
  1010.     { pop pop }
  1011.    ifelse
  1012.  } repeat
  1013. systemdict /BufferSpace known
  1014. systemdict /MaxBitmap known not and
  1015.  { /MaxBitmap BufferSpace
  1016.  } if
  1017. counttomark dup 0 ne
  1018.  { 2 add -1 roll putdeviceprops }
  1019.  { pop pop }
  1020. ifelse
  1021. setdevice        % does an erasepage
  1022. % If the media size is fixed, update the current page device dictionary.
  1023. FIXEDMEDIA not { (%END MEDIA) .skipeof } if
  1024. currentpagedevice dup length dict copy
  1025. dup /InputAttributes
  1026. 2 copy get dup length dict copy
  1027.     % Stack: <pagedevice> <pagedevice> /InputAttributes <inputattrs>
  1028. dup length dict copy dup
  1029. 0 2 copy get dup length dict copy
  1030.     % Stack: <pagedevice> <pagedevice> /InputAttributes
  1031.     %   <inputattrs> <inputattrs> 0 <attrs0>
  1032. dup /PageSize 7 index /PageSize get
  1033. put                % PageSize in 0
  1034. put                % 0 in InputAttributes
  1035. put                % InputAttributes in pagedevice
  1036. .setpagedevice        
  1037. %END MEDIA
  1038. %END DISPLAYING
  1039.  
  1040. (END DEVICE) VMDEBUG
  1041.  
  1042. % Establish a default upper limit in the character cache,
  1043. % namely, enough room for a 18-point character at the resolution
  1044. % of the default device, or for a character consuming 1% of the
  1045. % maximum cache size, whichever is larger.
  1046. mark
  1047.     % Compute limit based on character size.
  1048.   18 dup dtransform
  1049.   exch abs cvi 31 add 32 idiv 4 mul    % X raster
  1050.   exch abs cvi mul        % Y
  1051.     % Compute limit based on allocated space.
  1052.   cachestatus pop pop pop pop pop exch pop 0.01 mul cvi
  1053.   .max dup 10 idiv exch
  1054. setcacheparams
  1055. % Conditionally disable the character cache.
  1056. NOCACHE { 0 setcachelimit } if
  1057.  
  1058. (END CONFIG) VMDEBUG
  1059.  
  1060. % Establish an appropriate halftone screen.
  1061. % We make this a procedure so we can call it again when switching devices.
  1062.  
  1063. % Use an ordered dither for low-resolution devices.
  1064. /.setloresscreen    % <dpi> .setloresscreen -
  1065.  {    % The following 'ordered dither' spot function was contributed by
  1066.     % Gregg Townsend.  Thanks, Gregg!
  1067.    16.001 div 0            % not 16: avoids rounding problems
  1068.     { 1 add 7.9999 mul cvi exch 1 add 7.9999 mul cvi 16 mul add <
  1069.     0E 8E 2E AE 06 86 26 A6 0C 8C 2C AC 04 84 24 A4
  1070.     CE 4E EE 6E C6 46 E6 66 CC 4C EC 6C C4 44 E4 64
  1071.     3E BE 1E 9E 36 B6 16 96 3C BC 1C 9C 34 B4 14 94
  1072.     FE 7E DE 5E F6 76 D6 56 FC 7C DC 5C F4 74 D4 54
  1073.     01 81 21 A1 09 89 29 A9 03 83 23 A3 0B 8B 2B AB
  1074.     C1 41 E1 61 C9 49 E9 69 C3 43 E3 63 CB 4B EB 6B
  1075.     31 B1 11 91 39 B9 19 99 33 B3 13 93 3B BB 1B 9B
  1076.     F1 71 D1 51 F9 79 D9 59 F3 73 D3 53 FB 7B DB 5B
  1077.     0D 8D 2D AD 05 85 25 A5 0F 8F 2F AF 07 87 27 A7
  1078.     CD 4D ED 6D C5 45 E5 65 CF 4F EF 6F C7 47 E7 67
  1079.     3D BD 1D 9D 35 B5 15 95 3F BF 1F 9F 37 B7 17 97
  1080.     FD 7D DD 5D F5 75 D5 55 FF 7F DF 5F F7 77 D7 57
  1081.     02 82 22 A2 0A 8A 2A AA 00 80 20 A0 08 88 28 A8
  1082.     C2 42 E2 62 CA 4A EA 6A C0 40 E0 60 C8 48 E8 68
  1083.     32 B2 12 92 3A BA 1A 9A 30 B0 10 90 38 B8 18 98
  1084.     F2 72 D2 52 FA 7A DA 5A F0 70 D0 50 F8 78 D8 58
  1085.      > exch get 256 div
  1086.     }
  1087.    bind
  1088.         % Use correct, per-plane screens for CMYK devices only.
  1089.    systemdict /setcolorscreen known processcolors 4 eq and
  1090.     { 3 copy 6 copy setcolorscreen }
  1091.     { setscreen }
  1092.    ifelse
  1093.    0 array cvx settransfer    % Genoa CET won't accept a packed array!
  1094.    /setstrokeadjust where { pop true setstrokeadjust } if
  1095.  } bind def
  1096. % Use a 45-degree spot screen for high-resolution devices.
  1097. /.sethiresscreen    % <dpi> .sethiresscreen -
  1098.  {    % According to information published by Hewlett-Packard,
  1099.     % they use a 60 line screen on 300 DPI printers and
  1100.     % an 85 line screen on 600 DPI printers.
  1101.     % 46 was suggested as a good frequency value for printers
  1102.     % between 200 and 400 DPI, so we use it for lower resolutions.
  1103.    systemdict /DITHERPPI known
  1104.     { DITHERPPI }
  1105.     { dup cvi 100 idiv 6 .min {null 46 46 60 60 60 85} exch get }
  1106.    ifelse
  1107.    1 index 4.01 div .min    % at least a 4x4 cell
  1108.    45
  1109.     % The following screen algorithm is used by permission of the author.
  1110.     { 1 add 180 mul cos 1 0.08 add mul exch 2 add 180 mul cos 
  1111.       1 0.08 sub mul add 2 div % (C) 1989 Berthold K.P. Horn
  1112.     }
  1113.    bind
  1114.     % Ghostscript currently doesn't use correct, per-plane halftones
  1115.     % unless setcolorscreen has been executed.  Since these are
  1116.     % computationally much more expensive than binary halftones,
  1117.     % we check to make sure they are really warranted, i.e., we have
  1118.     % a high-resolution CMYK device (i.e., not a display) with
  1119.     % fewer than 5 bits per plane (i.e., not a true-color device).
  1120.    4 -1 roll 150 ge
  1121.     { /setcolorscreen where
  1122.        { pop defaultdevice getdeviceprops .dicttomark
  1123.          dup dup dup /RedValues known exch /GreenValues known and
  1124.        exch /BlueValues known and
  1125.       { dup dup /RedValues get 32 lt
  1126.           exch /GreenValues get 32 lt and
  1127.           exch /BlueValues get 32 lt and
  1128.          { 3 copy 6 copy
  1129.     % For really high-quality screening on printers, we need to
  1130.     % give each plane its own screen angle.  Unfortunately,
  1131.     % this currently has very large space and time costs.
  1132.     %**************** Uncomment the next line for high-quality screening.
  1133.         { 45 90 15 75 } { 3 1 roll exch pop 12 3 roll } forall
  1134.            setcolorscreen
  1135.          }
  1136.          { setscreen
  1137.          }
  1138.         ifelse
  1139.       }
  1140.       { pop setscreen
  1141.       }
  1142.      ifelse
  1143.        }
  1144.        { setscreen
  1145.        }
  1146.       ifelse
  1147.     }
  1148.     { setscreen
  1149.     }
  1150.    ifelse
  1151.     % Set the transfer function to lighten up the grays.
  1152.     % We correct at the high end so that very light grays
  1153.     % don't disappear completely if they darken <1 screen pixel.
  1154.     % Parameter values closer to 1 are better for devices with
  1155.     % less dot spreading; lower values are better with more spreading.
  1156.     % The value 0.8 is a compromise that will probably please no one!
  1157.     { 0.8 exp dup dup 0.9375 gt exch 0.999 lt and    % > 15/16
  1158.        { .currentscreenlevels 1 sub    % tweak to avoid boundary
  1159.      1 exch div 1 exch sub .min
  1160.        }
  1161.       if
  1162.     }
  1163.    settransfer
  1164.    /setstrokeadjust where { pop false setstrokeadjust } if
  1165.     % Increase fill adjustment so that we effectively use Adobe's
  1166.     % any-part-of-pixel rule.
  1167.    0.5 .setfilladjust
  1168.  } bind def
  1169. % Set the default screen based on the device resolution.
  1170. /.setdefaultscreen
  1171.  {    % Compute min(|dpi x|,|dpi y|) as the definition of the resolution.
  1172.    72 72 matrix defaultmatrix dtransform abs exch abs .min    %
  1173.    dup 150 lt systemdict /DITHERPPI known not and
  1174.     { .setloresscreen } { .sethiresscreen }
  1175.    ifelse
  1176.  } bind def
  1177. .setdefaultscreen
  1178. initgraphics
  1179. % The interpreter relies on there being at least 2 entries
  1180. % on the graphics stack.  Establish the second one now.
  1181. gsave
  1182.  
  1183. % Define some control sequences as no-ops.
  1184. % This is a hack to get around problems
  1185. % in some common PostScript-generating applications.
  1186. % Note that <04> and <1a> are self-delimiting characters, like [.
  1187. <04> cvn { } def        % Apple job separator
  1188. %<0404> cvn { } def        % two of the same
  1189. <1b> cvn { } def        % MS Windows LaserJet 4 prologue
  1190. %<041b> cvn { } def        % MS Windows LaserJet 4 epilogue
  1191. (\001M) cvn            % TBCP initiator
  1192.  { currentfile /TBCPDecode filter cvx exec
  1193.  } bind def
  1194. /@PJL                % H-P job control
  1195.  { currentfile //=string readline { pop } if
  1196.  } bind def
  1197.  
  1198. % If we want a "safer" system, disable some obvious ways to cause havoc.
  1199. SAFER not { (%END SAFER) .skipeof } if
  1200. /file
  1201.  { dup (r) eq 2 index (%pipe*) .stringmatch not and
  1202.     { file }
  1203.     { /invalidfileaccess signalerror }
  1204.    ifelse
  1205.  } bind odef
  1206. /renamefile { /invalidfileaccess signalerror } odef
  1207. /deletefile { /invalidfileaccess signalerror } odef
  1208. /putdeviceprops
  1209.  { counttomark
  1210.    dup 2 mod 0 eq { pop /rangecheck signalerror } if
  1211.    3 2 3 2 roll
  1212.     { dup index /OutputFile eq  
  1213.        { -2 roll 
  1214.          dup () ne { /putdeviceprops load /invalidfileaccess signalerror } if
  1215.          3 -1 roll
  1216.        }
  1217.        { pop
  1218.        }
  1219.       ifelse
  1220.     } for
  1221.    putdeviceprops
  1222.  } bind odef
  1223.  
  1224. %END SAFER
  1225.  
  1226. % Turn off array packing, since some PostScript code assumes that
  1227. % procedures are writable.
  1228. false setpacking
  1229.  
  1230. % Close up systemdict.
  1231. currentdict /.forceput undef        % remove temptation
  1232. currentdict /filterdict undef        % bound in where needed
  1233. end
  1234. WRITESYSTEMDICT not { systemdict readonly pop } if
  1235.  
  1236. (END INIT) VMDEBUG
  1237.  
  1238. % Establish local VM as the default.
  1239. false /setglobal where { pop setglobal } { .setglobal } ifelse
  1240. $error /.nosetlocal false put
  1241.  
  1242. % Clean up VM, and enable GC.
  1243. /vmreclaim where
  1244.  { pop NOGC not { 2 vmreclaim 0 vmreclaim } if
  1245.  } if
  1246.  
  1247. (END GC) VMDEBUG
  1248.  
  1249. % The interpreter will run the initial procedure (start).
  1250.